/*Arquivo que possui todos os controles do mapa*/

/*Variável para controlar controle de alternancia de layer, indica se o controle
 * está atiavo*/
var isActiveCtrLayerSwitch = false;
/*Variável para controlar alternancia de controle Overview, indica se o controle
 * está atiavo*/
var isActiveCtrOverview = false;
/*Variável para controlar alternancia de controle barra de escala, indica se o controle
 * está atiavo*/
var isActiveCtrScaleBar = false;
/*Variável para controlar visibilidade da legenda*/
var legendIsActive = false;

/*Função jquery, iniciada quando documento é carregado*/
$(document).ready(function() {
  
    /*Cria array de desenhos*/
    drawControls = {
        /*Cria desenho de ponto*/
        point: new OpenLayers.Control.DrawFeature(drawLayer,
                OpenLayers.Handler.Point),
        /*Cria desenho de linha*/
        line: new OpenLayers.Control.DrawFeature(drawLayer,
                OpenLayers.Handler.Path),
        /*Cria desenho de poligano*/
        polygon: new OpenLayers.Control.DrawFeature(drawLayer,
                OpenLayers.Handler.Polygon),
        /*Cria desenho de caixa*/
        box: new OpenLayers.Control.DrawFeature(drawLayer,
                OpenLayers.Handler.RegularPolygon, {
                    handlerOptions: {
                        sides: 4,
                        irregular: true
                    }
                }
        )
    };
    /*For para adicionar todos os controles de desenho ao mapa*/
    for (var key in drawControls) {
        map.addControl(drawControls[key]);
    }
    
 /*-----------------------Controle de mensuração-------------------------*/
            /*Cria estilos para os desenhos*/
            var sketchSymbolizers = {
                "Point": {
                    pointRadius: 4,
                    graphicName: "square",
                    fillColor: "white",
                    fillOpacity: 1,
                    strokeWidth: 1,
                    strokeOpacity: 1,
                    strokeColor: "#333333"
                },
                "Line": {
                    strokeWidth: 3,
                    strokeOpacity: 1,
                    strokeColor: "#666666",
                    strokeDashstyle: "dash"
                },
                "Polygon": {
                    strokeWidth: 2,
                    strokeOpacity: 1,
                    strokeColor: "#666666",
                    fillColor: "white",
                    fillOpacity: 0.3
                }
            };
            /*Cria uma novo estilo*/
            var style = new OpenLayers.Style();
            style.addRules([
                new OpenLayers.Rule({symbolizer: sketchSymbolizers})
            ]);
            /*Cria um novo estilo de mapa*/
            var styleMap = new OpenLayers.StyleMap({"default": style});
            
            // allow testing of specific renderers via "?renderer=Canvas", etc
            var renderer = OpenLayers.Util.getParameters(window.location.href).renderer;
            renderer = (renderer) ? [renderer] : OpenLayers.Layer.Vector.prototype.renderers;
            /*Cria controle de desenhos*/
            measureControls = {
                line: new OpenLayers.Control.Measure(
                    OpenLayers.Handler.Path, {
                        persist: true,
                        immediate : true,
                        displaySystem: ("metric"),
                        handlerOptions: {
                            layerOptions: {
                                renderers: renderer,
                                styleMap: styleMap
                            }
                        }
                    }
                ),
                polygon: new OpenLayers.Control.Measure(
                    OpenLayers.Handler.Polygon, {
                        persist: true,
                        handlerOptions: {
                            layerOptions: {
                                renderers: renderer,
                                styleMap: styleMap
                            }
                        }
                    }
                )
            };
            /*Adiciona evento aos controles criados
             * evento: vincula função quando os controles são chamados*/
            var controlMeasureEvent;
            for(var key in measureControls) {
                controlMeasureEvent = measureControls[key];
                controlMeasureEvent.events.on({
                    //"measurepartial": handleMeasurements,
                    "measure": handleMeasurements
                   // "activate": measurementToolActivated
                });
                map.addControl(controlMeasureEvent);
            }
/*-----------------------Fim Controle de mensuração-------------------------*/

/*Conrtole de historico de navegação*/
    nav = new OpenLayers.Control.NavigationHistory();
    /*Adiciona controle de navegação ao mapa*/
    map.addControl(nav);
    /*Cria painel para referenciar o controle*/
    panel = new OpenLayers.Control.Panel(
            {div: document.getElementById("historyControl")}
    );
    /*adiciona controle de avançar, e retroagir*/
    panel.addControls([nav.next, nav.previous]);
    /*Adiciona painel ao mapa*/
    map.addControl(panel);
    
});   

/*Função que carrega outras funções para desativar todos os controles do mapa*/
function desativeAllCtrs() {
    /*Loop para desativar todos os controle de navegação*/ /*Verificar ativo e deseativar*/
    for (controls in navigationControls) {
           if (navigationControls[controls].active) {
            navigationControls[controls].deactivate();
        }
    }
      /*Loop para interagir com todos os controles de medida e desativa-los*/
     for(controls in measureControls) {
           if (measureControls[controls].active) {
            measureControls[controls].deactivate();
        }
    }
     /*Loop para interagir com todos os controles de desenho e desativa-los*/
    for (controls in drawControls) {
          if (drawControls[controls].active) {
            drawControls[controls].deactivate();
        }
    }
    if(layerRegiao.getVisibility()) {
        infoLayers.deactivate();
    }
}

/*Função para ativar a legenda*/
function addMapLegend() { /*Mapa*/
    /*Verifica se a camada está visivel*/
    if(layerRegiao.getVisibility()) {
        /*Verifica se a legenda está desativada*/
        if (!legendIsActive) {
            /*Inclui a legenda a divLegenda do html*/
            $("#divLegenda").append("<img src='http://localhost:8080/geoserver/\n\wms?REQUEST=GetLegendGraphic&VERSION=1.0.0&FORMAT=image/\n\png&WIDTH=20&HEIGHT=40&LAYER=TB_REGIAO&style=teste' id='styleLegend'>");
            /*Modifica o estado da legenda para ativo*/
            legendIsActive = true;
          /*Se a visibilidade da legenda estiver falso*/
        }
      /*Se a camada não estiver visivel*/
    } else {
        /*Mostra alerta na tela*/
        alert("Para ver legenda, favor carregar camada!");
    }
}
/*Função para remover a legenda da camada*/
function removeMapLegend() { /*Mapa*/
    /*remove o elemento html da legenda*/
    $("#styleLegend").remove();
    /*modifica a visibilidade da legenda para falso*/
    legendIsActive = false; 
}
/*Função para criar e adiciona controle de geolocalização ao mapa*/
function geolocation() {
    
    /*--------------------Controle: Geolocalização--------------------*/
    
    /*Cria vetor para desenho*/
    vector = new OpenLayers.Layer.Vector("vector");
    /*Adiciona vetor e camada ao mapa*/
    map.addLayers([vector]);

    /*Cria estilo para desenho*/
    var style = {
        fillColor: '#000',
        fillOpacity: 0.1,
        strokeWidth: 0
    };
    /*Cria o controle de geolocalização*/
    geolocate = new OpenLayers.Control.Geolocate({
        bind: false,
        geolocationOptions: {
            enableHighAccuracy: false,
            maximumAge: 0,
            timeout: 7000
        }
    });
    /*Adiciona o controle ao mapa*/
    map.addControl(geolocate);
    /*Variável de controle para saber se é a primeira localização*/
    firstGeolocation = true;
    /*Registra evento no controle*/
    geolocate.events.register("locationupdated", geolocate, function(e) {
        vector.removeAllFeatures();
        var circle = new OpenLayers.Feature.Vector(
                OpenLayers.Geometry.Polygon.createRegularPolygon(
                        new OpenLayers.Geometry.Point(e.point.x, e.point.y),
                        e.position.coords.accuracy / 2,
                        40,
                        0
                        ),
                {},
                style
                );
        /*Aplica desenho no vetor*/
        vector.addFeatures([
            new OpenLayers.Feature.Vector(
                    e.point,
                    {},
                    {
                        graphicName: 'cross',
                        strokeColor: '#000080',
                        strokeWidth: 2,
                        fillOpacity: 0,
                        pointRadius: 10
                    }
            ),
            circle
        ]);
        /*Faz a verficiação da variável para saber se já foi clicado*/
        if (firstGeolocation) {
            /*Faz o zoom do local*/
            map.zoomToExtent(vector.getDataExtent());
            /*Modifica a variável para falso*/
            firstGeolocation = false;
            this.bind = true;
        }
    });
    /*Adiciona evento caso o controle dê erro*/
    geolocate.events.register("locationfailed", this, function() {
        /*Mostra no console o error*/
        OpenLayers.Console.log('Location detection failed');
    });
    
}
/*Função para controlar a alternancia de visibilidade do controle de @geolocation()*/
function toogleGeolocation() {
        vector.removeAllFeatures();
        geolocate.deactivate();
        geolocate.watch = false;
        firstGeolocation = true;
        geolocate.activate();
        layerRegiao.setVisibility(false);
}
/*Função que controla a alternancia dos controles de desenho do mapa*/
function toggleDrawFeature(element) {
    /*Pega o atributo "value" do elemento html*/
    var value = $(element).attr("value");

    /*Função que desativa todos os controles*/
    desativeAllCtrs();
    /*Loop para interagir com todos os controles do array desenho*/
    for (controls in drawControls) {
        /*Atribui os valores a variavel*/
        var control = drawControls[controls];
        /*Verifica se o valor do atributo "value" do elemento html é igual ao
         * do array*/
        if (value == controls) {
            /*Ativa os controle*/
            control.activate();
        }
    }
}

/*Função responsável por controlar a alternancia do controle de mensuração*/
function toggleMeasureControl(element) {
    /*Pega o atributo "value" do elemento html*/
    var value = $(element).attr("value");
    /*Mostra o output*/

    if (!outputMeasureActive) {
        $("#output").show();
    }
    
    /*Função que desativa todos os controles*/
    desativeAllCtrs();

    for (controls in measureControls) {
        var control = measureControls[controls];
        if (value == controls) {
            control.activate();
        }
    }
}
/*Função que trata os eventos de mensuração*/
function handleMeasurements(event) {
    /*Variável que pega o tipo de unidade de medida*/
    var units = event.units;
    var order = event.order;
    /*Variável que pega o valor da medida*/
    var measure = event.measure;
    /*Variável que pega o elemento "output" do html*/
    var element = document.getElementById("output");
    /*Atribui uma string vazia a variavel*/
    var out = "";
    if (order == 1) {
        out += "measure: " + measure.toFixed(3) + " " + units;
    } else {
        out += "measure: " + measure.toFixed(3) + " " + units + "<sup>2</" + "sup>";
    }
    /*Uni o valor de out ao elemento do html*/
    element.innerHTML = out;
}
/*Função responsável por fazer alternancia do controle de cluster do mapa*/
function toogleCluster() {
    /*Verifica se a camada cluster está ativa*/
    if (clusters.getVisibility()) {
        /*Se já estiver ativa, desativa a visibilidade*/
        clusters.setVisibility(false);
        /*Se a visibilidade estiver desativada*/
    } else {
        /*Altera a camada de cluster visivel*/
        clusters.setVisibility(true);
    }
}
/*Função que controla a alternancia do controle de heatMap*/
function toogleHeatMap() {
    /*Verifica se a camada cluster está ativa*/
    if (layerHeatMap.getVisibility()) {
        /*Se já estiver ativa, desativa a visibilidade*/
        layerHeatMap.setVisibility(false);
        /*Se a visibilidade estiver desativada*/
    } else {
        /*Altera a camada de heatmap para visivel*/
        layerHeatMap.setVisibility(true);
    }
}


/*Alterna informação de layer*/
function infoLayerModel(event) {
    /*variável com informções referentes a camada estados*/
    infoLayerRegiao =
            "<table>" +
                "<tr>" +
                    "<td  width='100'> <b>Sigla</b> </td>" +
                    "<td  width='100'> <b>Nome região</b> </td>" +
                "</tr>" +
                "<tr>" +
                /*Mostra os atributos da camada estados*/
                    "<td>" + event.features[0].attributes.SG_REGIAO + "</td>" +
                    "<td>" + event.features[0].attributes.NO_REGIAO + "</td>" +
                "</tr>" +
            "</table>";
    
    return infoLayerRegiao;
}


/*Função que faz alternancia de controle de visibilidade da camada*/
function toggleLayerOpl(layer) {
    if (layer.getVisibility()) {
        layer.setVisibility(false);
    } else {
        layer.setVisibility(true);
    }
}

function addInfoControl() {
    /*Cria janela de informção de layer*/ /*Controle*/
    infoLayers = new OpenLayers.Control.WMSGetFeatureInfo({
        url: "http://localhost:8080/geoserver/wms",
        title: 'Identify features by clicking',
        queryVisible: true,
        infoFormat: 'application/vnd.ogc.gml',
        eventListeners: {
            getfeatureinfo: function(event) {
                map.addPopup(new OpenLayers.Popup.FramedCloud(
                        "chicken",
                        map.getLonLatFromPixel(event.xy),
                        null,
                        /*Função para controlar as informções da camada ativa*/
                        infoLayerModel(event),
                        null,
                        true
                        ));
                console.info(event);
            }
        }
    });
    
    /*Adiciona ao mapa a estrutra necessária para mostrar informações da camada
    * estado e municipio*/
    map.addControl(infoLayers);
}
